Django Signallarini O'zlashtirish: Mustahkam Ilovalar uchun Post-save va Pre-delete Huklariga Chuqur Kirish

Veb-dasturlashning keng va murakkab dunyosida kengaytiriladigan, qo'llab-quvvatlanadigan va mustahkam ilovalarni yaratish ko'pincha komponentlarni ajratish va voqealarga uzluksiz reaksiya qilish qobiliyatiga bog'liq. Django o'zining "hammasi ichida" falsafasi bilan buning uchun kuchli mexanizmni taqdim etadi: Signallar Tizimi. Ushbu tizim ilovangizning turli qismlariga ma'lum harakatlar sodir bo'lganda bildirishnomalar yuborishga va boshqa qismlarga ushbu bildirishnomalarni tinglashga va ularga javob berishga imkon beradi, bularning barchasi to'g'ridan-to'g'ri bog'liqliksiz amalga oshiriladi.

Turli loyihalarda ishlaydigan global dasturchilar uchun Django Signallarini tushunish va samarali ishlatish shunchaki afzallik emas, balki nafis va chidamli tizimlarni yaratish uchun ko'pincha zaruratdir. Eng ko'p ishlatiladigan va muhim signallar orasida post_save va pre_delete mavjud. Bu ikki huk model nusxalaringizning hayotiy sikliga maxsus mantiqni kiritish uchun alohida imkoniyatlar yaratadi: biri ma'lumotlar saqlanganidan so'ng darhol, ikkinchisi esa ma'lumotlar o'chirilishidan oldin.

Ushbu keng qamrovli qo'llanma sizni Django Signallar Tizimiga chuqur sayohatga olib boradi, ayniqsa post_save va pre_delete atrofidagi amaliy tatbiq va eng yaxshi amaliyotlarga e'tibor qaratadi. Biz ularning parametrlarini o'rganamiz, batafsil kod misollari bilan real hayotdagi foydalanish holatlariga kirib boramiz, umumiy xatoliklarni muhokama qilamiz va sizni jahon darajasidagi Django ilovalarini yaratish uchun ushbu kuchli vositalardan foydalanish uchun bilimlar bilan ta'minlaymiz.

Django Signallar Tizimini Tushunish: Asos

O'z mohiyatiga ko'ra, Django Signallar Tizimi kuzatuvchi dizayn na'munasining (observer design pattern) amalga oshirilishidir. U "yuboruvchi"ga bir guruh "qabul qiluvchilar"ga qandaydir harakat sodir bo'lganligi haqida xabar berish imkonini beradi. Bu yuqori darajada ajratilgan arxitekturani rivojlantiradi, bunda komponentlar bilvosita aloqa qilib, o'zaro bog'liqliklarni kamaytiradi va modullikni yaxshilaydi.

Signallar Tizimining Asosiy Komponentlari:

• Signallar: Bular dispetcherlar. Ular django.dispatch.Signal sinfining nusxalaridir. Django bir qator o'rnatilgan signallarni taqdim etadi (masalan, post_save, pre_delete, request_started va boshqalar), shuningdek, o'zingizning maxsus signallaringizni ham belgilashingiz mumkin.
• Yuboruvchilar: Signal chiqaradigan obyektlar. O'rnatilgan signallar uchun bu odatda model sinfi yoki ma'lum bir nusxadir.
• Qabul qiluvchilar (yoki Callbacks): Bular signal yuborilganda bajariladigan Python funksiyalari yoki metodlaridir. Qabul qiluvchi funksiya signal uzatadigan maxsus argumentlarni qabul qiladi.
• Ulanish: Qabul qiluvchi funksiyani ma'lum bir signalga ro'yxatdan o'tkazish jarayoni. Bu signallar tizimiga: "Qachonki bu voqea sodir bo'lsa, o'sha funksiyani chaqir" degan ma'noni anglatadi.

Tasavvur qiling, sizda har safar yangi User hisobi ro'yxatdan o'tkazilganda yaratilishi kerak bo'lgan UserProfile modeli bor. Signallarsiz siz foydalanuvchini ro'yxatdan o'tkazish view'ini o'zgartirishingiz yoki User modelining save() metodini qayta yozishingiz mumkin edi. Bu yondashuvlar ishlasa-da, ular UserProfile yaratish mantiqini to'g'ridan-to'g'ri User modeliga yoki uning view'lariga bog'lab qo'yadi. Signallar esa toza, ajratilgan alternativani taklif qiladi.

Signalni Ulashning Asosiy Misoli:

Bu yerda signalni qanday ulashning oddiy misoli keltirilgan:

            # myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.contrib.auth.models import User

# Qabul qiluvchi funksiyani aniqlash
@receiver(post_save, sender=User)
def create_user_profile(sender, instance, created, **kwargs):
    if created:
        # Yangi foydalanuvchi uchun profil yaratish mantig'i
        print(f"Yangi foydalanuvchi '{instance.username}' yaratildi. Endi profil yaratilishi mumkin.")

# Shu bilan bir qatorda, qo'lda ulash (o'rnatilgan signallar uchun dekorator bilan kamroq tarqalgan)
# from django.apps import AppConfig
# class MyAppConfig(AppConfig):
#     name = 'myapp'
#     def ready(self):
#         from . import signals  # Signallar faylingizni import qilish

            

              
                Copy
              
            
          

Ushbu kod parchasida create_user_profile funksiyasi post_save signali uchun, ayniqsa u User modeli tomonidan yuborilganda, qabul qiluvchi sifatida belgilanadi. @receiver dekoratori ulanish jarayonini soddalashtiradi.

post_save Signali: Saqlashdan Keyingi Reaksiya

post_save signali Django'ning eng keng qo'llaniladigan signallaridan biridir. U model nusxasi har safar saqlanganda, u yangi obyekt bo'ladimi yoki mavjudining yangilanishi bo'ladimi, yuboriladi. Bu uni ma'lumotlar bazasiga muvaffaqiyatli yozilganidan so'ng darhol bajarilishi kerak bo'lgan vazifalar uchun juda ko'p qirrali qiladi.

post_save Qabul Qiluvchilarining Asosiy Parametrlari:

Funksiyani post_save ga ulanganda, u bir nechta argumentlarni qabul qiladi:

• sender: Signalni yuborgan model sinfi (masalan, User).
• instance: Saqlangan modelning haqiqiy nusxasi. Bu obyekt endi ma'lumotlar bazasidagi holatini aks ettiradi.
• created: Boolean qiymat; agar yangi yozuv yaratilgan bo'lsa True, agar mavjud yozuv yangilangan bo'lsa False. Bu shartli mantiq uchun juda muhimdir.
• raw: Boolean qiymat; agar model fixture yuklanishi natijasida saqlangan bo'lsa True, aks holda False. Odatda siz fixture'lardan yaratilgan signallarni e'tiborsiz qoldirishingiz kerak.
• using: Ishlatilayotgan ma'lumotlar bazasi taxallusi (masalan, 'default').
• update_fields: Model.save() ga update_fields argumenti sifatida uzatilgan maydon nomlari to'plami. Bu faqat yangilanishlar uchun mavjud.
• **kwargs: Uzatilishi mumkin bo'lgan har qanday qo'shimcha kalit so'zli argumentlar uchun universal ushlagich. Buni qo'shish yaxshi amaliyotdir.

post_save uchun Amaliy Foydalanish Holatlari:

1. Bog'liq Obyektlarni Yaratish (masalan, Foydalanuvchi Profili):

Bu klassik misoldir. Yangi foydalanuvchi ro'yxatdan o'tganda, ko'pincha unga bog'liq profil yaratish kerak bo'ladi. created=True sharti bilan post_save bu uchun juda mos keladi.

            # myapp/models.py
from django.db import models
from django.contrib.auth.models import User

class UserProfile(models.Model):
    user = models.OneToOneField(User, on_delete=models.CASCADE)
    bio = models.TextField(blank=True)
    location = models.CharField(max_length=100, blank=True)
    birth_date = models.DateField(null=True, blank=True)

    def __str__(self):
        return self.user.username + "'s Profile"

# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.contrib.auth.models import User
from .models import UserProfile

@receiver(post_save, sender=User)
def create_or_update_user_profile(sender, instance, created, **kwargs):
    if created:
        UserProfile.objects.create(user=instance)
        print(f"{instance.username} uchun UserProfile yaratildi.")
    # Ixtiyoriy: Agar siz User'ga qilingan yangilanishlarni ham qayta ishlashni va profilga kaskadlashni xohlasangiz
    # instance.userprofile.save() # Bu, agar UserProfile uchun post_save signali bo'lsa, uni ishga tushirardi

            

              
                Copy
              
            
          

2. Kesh yoki Qidiruv Indekslarini Yangilash:

Ma'lumotlar qismi o'zgarganda, siz keshlangan versiyalarni bekor qilishingiz yoki yangilashingiz, yoki tarkibni Elasticsearch yoki Solr kabi qidiruv tizimlarida qayta indekslashingiz kerak bo'lishi mumkin.

            # myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Product
from django.core.cache import cache

@receiver(post_save, sender=Product)
def update_product_cache_and_search_index(sender, instance, **kwargs):
    # Muayyan mahsulot keshini bekor qilish
    cache.delete(f"product_detail_{instance.pk}")
    print(f"Mahsulot ID: {instance.pk} uchun kesh bekor qilindi")

    # Qidiruv indeksini yangilashni simulyatsiya qilish
    # Haqiqiy hayotda bu tashqi qidiruv xizmati API'sini chaqirishni o'z ichiga olishi mumkin
    print(f"{instance.name} (ID: {instance.pk}) mahsuloti qidiruv indeksini yangilash uchun belgilandi.")
    # search_service.index_document(instance)

            

              
                Copy
              
            
          

3. Ma'lumotlar Bazasidagi O'zgarishlarni Jurnallashtirish:

Audit yoki nosozliklarni tuzatish maqsadlarida siz muhim modellarga kiritilgan har bir o'zgartirishni jurnalga yozib qo'yishni xohlashingiz mumkin.

            # myapp/models.py
from django.db import models

class AuditLog(models.Model):
    model_name = models.CharField(max_length=255)
    object_id = models.IntegerField()
    action = models.CharField(max_length=50) # 'created', 'updated'
    timestamp = models.DateTimeField(auto_now_add=True)
    changes = models.JSONField(blank=True, null=True)

    def __str__(self):
        return f"[{self.timestamp}] {self.model_name}({self.object_id}) {self.action}"

class BlogPost(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    published_date = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.title

# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import AuditLog, BlogPost # Audit qilinadigan misol model

@receiver(post_save, sender=BlogPost)
def log_blogpost_changes(sender, instance, created, **kwargs):
    action = 'created' if created else 'updated'
    # Yangilanishlar uchun siz ma'lum bir maydon o'zgarishlarini qayd etishni xohlashingiz mumkin. Bu pre-save taqqoslashni talab qiladi.
    # Bu yerda soddalik uchun biz faqat harakatni jurnalga yozamiz.
    AuditLog.objects.create(
        model_name=sender.__name__,
        object_id=instance.pk,
        action=action,
        # changes=previous_state_vs_current_state # Bu uchun murakkabroq mantiq kerak
    )
    print(f"BlogPost ID: {instance.pk} uchun audit jurnali yaratildi, harakat: {action}")

            

              
                Copy
              
            
          

4. Bildirishnomalar Yuborish (Email, Push, SMS):

Buyurtma tasdiqlanishi yoki yangi izoh kabi muhim voqeadan so'ng siz bildirishnomalarni ishga tushirishingiz mumkin.

            # myapp/models.py
from django.db import models

class Order(models.Model):
    customer_email = models.EmailField()
    status = models.CharField(max_length=50, default='pending')
    total_amount = models.DecimalField(max_digits=10, decimal_places=2)

    def __str__(self):
        return f"Buyurtma #{self.pk} - {self.customer_email}"

# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Order
from django.core.mail import send_mail
# from myapp.tasks import send_order_confirmation_email_task # Asinxron vazifalar uchun

@receiver(post_save, sender=Order)
def send_order_confirmation(sender, instance, created, **kwargs):
    if created and instance.status == 'pending': # Yoki sinxron qayta ishlansa 'completed'
        subject = f"Sizning Buyurtmangiz #{instance.pk} Tasdiqlandi"
        message = f"Hurmatli mijoz, buyurtmangiz uchun rahmat! Buyurtmangizning umumiy summasi {instance.total_amount}."
        from_email = "noreply@example.com"
        recipient_list = [instance.customer_email]

        try:
            send_mail(subject, message, from_email, recipient_list, fail_silently=False)
            print(f"Buyurtma ID: {instance.pk} uchun {instance.customer_email} manziliga buyurtma tasdiqlovi xati yuborildi")
        except Exception as e:
            print(f"Buyurtma ID {instance.pk} uchun email yuborishda xatolik: {e}")

        # Yaxshiroq ishlash va ishonchlilik uchun, ayniqsa tashqi xizmatlar bilan,
        # buni asinxron vazifalar navbatiga (masalan, Celery) kechiktirishni o'ylab ko'ring.
        # send_order_confirmation_email_task.delay(instance.pk)

            

              
                Copy
              
            
          

post_save uchun Eng Yaxshi Amaliyotlar va Mulohazalar:

• created bilan Shartli Mantiq: Agar mantig'ingiz faqat yangi obyektlar uchun yoki faqat yangilanishlar uchun ishlashi kerak bo'lsa, har doim created argumentini tekshiring.
• Cheksiz Tsikllardan Saqlaning: Agar sizning post_save qabul qiluvchingiz instanceni yana saqlasa, u o'zini rekursiv ravishda chaqirishi mumkin, bu esa cheksiz tsiklga va potentsial stek to'lib ketishiga olib keladi. Agar siz nusxani saqlasangiz, buni ehtiyotkorlik bilan, masalan, update_fields dan foydalanib yoki kerak bo'lganda signalni vaqtincha uzib qo'yib amalga oshiring.
• Ishlash Samaradorligi: Signal qabul qiluvchilaringizni yengil va tezkor saqlang. Og'ir operatsiyalar, ayniqsa elektron pochta yuborish yoki tashqi API'larni chaqirish kabi I/O-ga bog'liq vazifalarni asosiy so'rov-javob tsiklini bloklamaslik uchun asinxron vazifalar navbatiga (masalan, Celery, RQ) yuklash kerak.
• Xatoliklarni Qayta Ishlash: Qabul qiluvchilaringizda potentsial xatolarni oqilona boshqarish uchun mustahkam try-except bloklarini qo'llang. Signal qabul qiluvchisidagi xatolik asl saqlash operatsiyasining muvaffaqiyatli bajarilishiga to'sqinlik qilishi yoki hech bo'lmaganda xatoni foydalanuvchidan yashirishi mumkin.
• Idempotentlik: Qabul qiluvchilarni idempotent qilib loyihalashtiring, ya'ni ularni bir xil kirish bilan bir necha marta ishga tushirish ularni bir marta ishga tushirish bilan bir xil ta'sirga ega bo'ladi. Bu keshni bekor qilish kabi vazifalar uchun yaxshi amaliyotdir.
• Xom Saqlashlar: Odatda, raw True bo'lgan signallarni e'tiborsiz qoldirishingiz kerak, chunki ular ko'pincha sizning maxsus mantig'ingiz ishlashini istamaydigan fixture yuklanishi yoki boshqa ommaviy operatsiyalardan kelib chiqadi.

pre_delete Signali: O'chirishdan Oldin Aralashish

post_save ma'lumotlar yozilganidan keyin harakat qilsa, pre_delete signali model nusxasi ma'lumotlar bazasidan o'chirilishidan oldin muhim bir hukni taqdim etadi. Bu sizga obyekt hali mavjud va uning ma'lumotlari mavjud bo'lganda bajarilishi kerak bo'lgan tozalash, arxivlash yoki tasdiqlash vazifalarini bajarishga imkon beradi.

pre_delete Qabul Qiluvchilarining Asosiy Parametrlari:

Funksiyani pre_delete ga ulanganda, u quyidagi argumentlarni qabul qiladi:

• sender: Signalni yuborgan model sinfi.
• instance: O'chirilishi arafasida turgan modelning haqiqiy nusxasi. Bu uning ma'lumotlariga kirish uchun oxirgi imkoniyatingiz.
• using: Ishlatilayotgan ma'lumotlar bazasi taxallusi.
• **kwargs: Har qanday qo'shimcha kalit so'zli argumentlar uchun universal ushlagich.

pre_delete uchun Amaliy Foydalanish Holatlari:

1. Bog'liq Fayllarni Tozalash (masalan, Yuklangan Rasmlar):

Agar modelingizda FileField yoki ImageField bo'lsa, Django'ning standart xatti-harakati model nusxasi o'chirilganda bog'liq fayllarni saqlash joyidan avtomatik ravishda o'chirmaydi. pre_delete bu tozalashni amalga oshirish uchun eng yaxshi joy.

            # myapp/models.py
from django.db import models

class Document(models.Model):
    title = models.CharField(max_length=255)
    file = models.FileField(upload_to='documents/')

    def __str__(self):
        return self.title

# myapp/signals.py
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from .models import Document

@receiver(pre_delete, sender=Document)
def delete_document_file_on_delete(sender, instance, **kwargs):
    # Faylni o'chirishga urinishdan oldin uning mavjudligiga ishonch hosil qiling
    if instance.file:
        instance.file.delete(save=False) # haqiqiy faylni saqlash joyidan o'chirish
        print(f"Hujjat ID: {instance.pk} uchun '{instance.file.name}' fayli saqlash joyidan o'chirildi.")

            

              
                Copy
              
            
          

2. Qattiq O'chirish O'rniga Ma'lumotlarni Arxivlash:

Ko'pgina ilovalarda, ayniqsa nozik yoki tarixiy ma'lumotlar bilan ishlaydiganlarda, haqiqiy o'chirish tavsiya etilmaydi. Buning o'rniga, obyektlar yumshoq o'chiriladi yoki arxivlanadi. pre_delete o'chirish urinishini to'xtatib, uni arxivlash jarayoniga aylantirishi mumkin.

            # myapp/models.py
from django.db import models

class Customer(models.Model):
    name = models.CharField(max_length=255)
    email = models.EmailField(unique=True)
    is_active = models.BooleanField(default=True)
    archived_at = models.DateTimeField(null=True, blank=True)

    def __str__(self):
        return self.name

class ArchivedCustomer(models.Model):
    original_customer_id = models.IntegerField(unique=True)
    name = models.CharField(max_length=255)
    email = models.EmailField()
    archived_date = models.DateTimeField(auto_now_add=True)
    original_data_snapshot = models.JSONField(blank=True, null=True)

    def __str__(self):
        return f"Arxivlangan: {self.name} (ID: {self.original_customer_id})"

# myapp/signals.py
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from .models import Customer, ArchivedCustomer
from django.core.exceptions import PermissionDenied # Haqiqiy o'chirishni oldini olish uchun
from django.utils import timezone

@receiver(pre_delete, sender=Customer)
def archive_customer_instead_of_delete(sender, instance, **kwargs):
    # Arxivlangan nusxani yaratish
    ArchivedCustomer.objects.create(
        original_customer_id=instance.pk,
        name=instance.name,
        email=instance.email,
        original_data_snapshot={
            'is_active': instance.is_active,
            'archived_at': instance.archived_at.isoformat() if instance.archived_at else None
        }
    )
    print(f"Mijoz ID: {instance.pk} o'chirish o'rniga arxivlandi.")
    # Istisno ko'tarib, haqiqiy o'chirishni davom ettirishni oldini olish
    raise PermissionDenied(f"Mijoz '{instance.name}' qattiq o'chirilishi mumkin emas, faqat arxivlanishi mumkin.")
    # Eslatma: Haqiqiy yumshoq o'chirish na'munasi uchun, odatda siz modeldagi delete() metodini
    # qayta yozasiz yoki maxsus menejerdan foydalanasiz, chunki signallar ORM operatsiyasini osongina "bekor qila olmaydi".
```

# myapp/models.py
from django.db import models

class Project(models.Model):
    title = models.CharField(max_length=255)
    description = models.TextField(blank=True)

    def __str__(self):
        return self.title

class Task(models.Model):
    project = models.ForeignKey(Project, on_delete=models.CASCADE)
    name = models.CharField(max_length=255)
    is_completed = models.BooleanField(default=False)

    def __str__(self):
        return self.name

# myapp/signals.py
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from .models import Project, Task
from django.core.exceptions import PermissionDenied

@receiver(pre_delete, sender=Project)
def prevent_deletion_if_active_tasks(sender, instance, **kwargs):
    if instance.task_set.filter(is_completed=False).exists():
        raise PermissionDenied(
            f"'{instance.title}' Loyihasini o'chirish mumkin emas, chunki unda hali ham faol vazifalar mavjud."
        )
    print(f"'{instance.title}' Loyihasida faol vazifalar yo'q; o'chirish davom etmoqda.")

            

              
                Copy
              
            
          

            # myapp/models.py
from django.db import models

class CriticalReport(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()
    severity = models.CharField(max_length=50)

    def __str__(self):
        return f"{self.title} ({self.severity})"

# myapp/signals.py
from django.db.models.signals import pre_delete
from django.dispatch import receiver
from .models import CriticalReport
from django.core.mail import mail_admins
from django.utils import timezone

@receiver(pre_delete, sender=CriticalReport)
def alert_admin_on_critical_report_deletion(sender, instance, **kwargs):
    subject = f"MUHIM OGOHLANTIRISH: CriticalReport ID {instance.pk} o'chirilish arafasida"
    message = (
        f"Muhim Hisobot (ID: {instance.pk}, Sarlavha: '{instance.title}') "
        f"tizimdan o'chirilmoqda. "
        f"Bu harakat {timezone.now()} da boshlandi." 
        f"Iltimos, bu o'chirishning ruxsat etilganligini tekshiring."
    )
    mail_admins(subject, message, fail_silently=False)
    print(f"CriticalReport ID: {instance.pk} o'chirilishi uchun admin ogohlantirishi yuborildi")

            

              
                Copy
              
            
          

            # myapp/apps.py
from django.apps import AppConfig

class MyappConfig(AppConfig):
    default_auto_field = 'django.db.models.BigAutoField'
    name = 'myapp'

    def ready(self):
        # Signallaringiz ro'yxatdan o'tganligiga ishonch hosil qilish uchun ularni bu yerda import qiling
        # Bu, agar signallar bir xil ilova ichidagi modellarga murojaat qilsa, aylana importlarni oldini oladi
        import myapp.signals # Bu import yo'li ilovangiz tuzilishiga to'g'ri kelishiga ishonch hosil qiling

            

              
                Copy
              
            
          

            # update_fields bilan rekursiyadan saqlanish misoli
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Order

@receiver(post_save, sender=Order)
def update_order_status_if_needed(sender, instance, created, **kwargs):
    if created: # Faqat yangi buyurtmalar uchun
        if instance.total_amount > 1000 and instance.status == 'pending':
            instance.status = 'approved_high_value'
            instance.save(update_fields=['status'])
            print(f"Buyurtma ID {instance.pk} statusi 'approved_high_value' ga yangilandi (rekursiv bo'lmagan saqlash).")
```

# myapp/signals.py
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.db import transaction
from .models import Photo # Photo modelida ImageField bor deb faraz qilamiz
# import os # Haqiqiy fayl operatsiyalari uchun
# from django.conf import settings # Media root yo'llari uchun
# from PIL import Image # Rasm qayta ishlash uchun

class Photo(models.Model):
    title = models.CharField(max_length=255)
    image = models.ImageField(upload_to='photos/')

    def __str__(self):
        return self.title

@receiver(post_save, sender=Photo)
def generate_thumbnails_on_commit(sender, instance, created, **kwargs):
    if created and instance.image:
        def _on_transaction_commit():
            # Bu kod faqat Photo obyekti DB'ga muvaffaqiyatli saqlangandagina ishlaydi
            print(f"Muvaffaqiyatli saqlashdan so'ng Photo ID: {instance.pk} uchun eskiz yaratilmoqda.")
            # Eskiz yaratishni simulyatsiya qilish (masalan, Pillow yordamida)
            # try:
            #     img = Image.open(instance.image.path)
            #     img.thumbnail((128, 128))
            #     thumb_dir = os.path.join(settings.MEDIA_ROOT, 'thumbnails')
            #     os.makedirs(thumb_dir, exist_ok=True)
            #     thumb_path = os.path.join(thumb_dir, f'thumb_{instance.image.name}')
            #     img.save(thumb_path)
            #     print(f"Eskiz {thumb_path} ga saqlandi")
            # except Exception as e:
            #     print(f"Photo ID {instance.pk} uchun eskiz yaratishda xatolik: {e}")

        transaction.on_commit(_on_transaction_commit)

            

              
                Copy
              
            
          

# myapp/tests.py
from django.test import TestCase
from django.db.models.signals import post_save
from django.contrib.auth.models import User
from myapp.models import UserProfile # UserProfile signal tomonidan yaratilgan deb faraz qiling
from myapp.signals import create_or_update_user_profile

class UserProfileSignalTest(TestCase):

    @classmethod
    def setUpClass(cls):
        super().setUpClass()
        # Bu sinfdagi barcha testlar uchun signalni global ravishda uzib qo'yish
        # Bu signalning test uchun maxsus ulanmaguncha ishga tushishini oldini oladi
        post_save.disconnect(receiver=create_or_update_user_profile, sender=User)

    @classmethod
    def tearDownClass(cls):
        super().tearDownClass()
        # Bu sinfdagi barcha testlar tugagandan so'ng signalni qayta ulash
        post_save.connect(receiver=create_or_update_user_profile, sender=User)

    def test_user_creation_does_not_create_profile_without_signal(self):
        user = User.objects.create_user(username='testuser_no_signal', password='password123')
        self.assertFalse(UserProfile.objects.filter(user=user).exists())
        
    def test_user_creation_creates_profile_with_signal(self):
        # Signalni faqat u ishga tushishi kerak bo'lgan ushbu maxsus test uchun ulash
        # Agar iloji bo'lsa, boshqa testlarga ta'sir qilmaslik uchun vaqtinchalik ulanishdan foydalaning
        post_save.connect(receiver=create_or_update_user_profile, sender=User)
        try:
            user = User.objects.create_user(username='testuser_with_signal', password='password123')
            self.assertTrue(UserProfile.objects.filter(user=user).exists())
        finally:
            # Keyinchalik uzilganligiga ishonch hosil qilish
            post_save.disconnect(receiver=create_or_update_user_profile, sender=User)

    def test_create_or_update_user_profile_receiver_directly(self):
        user = User.objects.create_user(username='testuser_direct', password='password123')
        self.assertFalse(UserProfile.objects.filter(user=user).exists())

        # Qabul qiluvchi funksiyani to'g'ridan-to'g'ri chaqirish
        create_or_update_user_profile(sender=User, instance=user, created=True)
        self.assertTrue(UserProfile.objects.filter(user=user).exists())

```